package org.x.usermod.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import com.mybatisflex.core.query.QueryWrapper;
import com.mybatisflex.core.util.UpdateEntity;
import com.mybatisflex.spring.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PostMapping;
import org.x.usermod.entity.SysConfigEntity;
import org.x.usermod.entity.SysConfigHistoryEntity;
import org.x.usermod.mapper.ConfigHistoryMapper;
import org.x.usermod.mapper.ConfigMapper;
import org.x.usermod.service.ConfigService;

import org.springframework.stereotype.Service;

import java.util.*;
import java.util.concurrent.TimeUnit;

@Service
public class ConfigServiceImpl extends ServiceImpl<ConfigMapper, SysConfigEntity> implements ConfigService {
    @Autowired
    private ConfigMapper configMapper;
    // 注入RedisTemplate
    @Autowired
    private  RedisTemplate<String, Object> redisTemplate;
    @Autowired
    private ConfigHistoryMapper configHistoryMapper;
    /**
     * 获取所有配置
     * @return
     */
    @Override
    public List<SysConfigEntity> getConfigList() {
        List<SysConfigEntity> sysConfigEntitiesList;
        Random random = new Random();

        // 从Redis中获取配置
        Map<Object, Object> configMap = redisTemplate.opsForHash().entries("config");
        if (configMap.isEmpty()) {
            // 从数据库中查询全部配置
            sysConfigEntitiesList = configMapper.selectAll();
            if (sysConfigEntitiesList != null && !sysConfigEntitiesList.isEmpty()) {
                // 存入Redis并设置过期时间
                for (SysConfigEntity sysConfigEntity : sysConfigEntitiesList) {
                    // 存储实体对象到Hash中
                    redisTemplate.opsForHash().put("config",
                            sysConfigEntity.getConfigKey(),
                            sysConfigEntity);
                }
                // 随机生成1-100秒的过期时间
                long timeout = random.nextLong(100) + 1;
                redisTemplate.expire("config", timeout, TimeUnit.SECONDS);
            }
        } else {
            // 将Hash中的值转换为List<SysConfigEntity>
            sysConfigEntitiesList = new ArrayList<>(configMap.size());
            for (Object value : configMap.values()) {
                // 转换为实体类型
                if (value instanceof SysConfigEntity) {
                    sysConfigEntitiesList.add((SysConfigEntity) value);
                }
            }
        }

        // 确保返回非null集合
        return sysConfigEntitiesList != null ? sysConfigEntitiesList : new ArrayList<>();
    }

    /**
     * 刷新缓存
     * @return
     */
    @PostMapping("/refreshCache")
    public List<SysConfigEntity> refreshConfig(){
        List<SysConfigEntity> sysConfigEntities = new ArrayList<SysConfigEntity>();
        //删除redis当中的缓存
        redisTemplate.delete("configList");
        //重新加载配置
        return getConfigList();
    }

    /**
     * 查询公共配置
     * @return
     */
    @Override
    public List<SysConfigEntity> getPublicConfig() {
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.eq("isPublic", 1);
        List<SysConfigEntity> publicConfig = configMapper.selectListByQuery(queryWrapper);
        //存入redis
        redisTemplate.opsForValue().set("publicConfig", publicConfig,5,TimeUnit.DAYS);
        return  publicConfig;
    }
    /**
     * 更新配置
     * @param id
     * @param configValue
     */
    @Override
    @Transactional
    public void updateConfig(Integer id, String configValue) {
        //查出这条配置
        SysConfigEntity sysConfigEntity = configMapper.selectOneById(id);
        //更新历史记录
        SysConfigHistoryEntity sysConfigHistoryEntity = new SysConfigHistoryEntity();
        Integer configId = sysConfigEntity.getId();
        String configKey = sysConfigEntity.getConfigKey();
        String oldValue = sysConfigEntity.getConfigValue();
        Long operatorId = StpUtil.getLoginIdAsLong();
        sysConfigHistoryEntity.setConfigId(configId);
        sysConfigHistoryEntity.setConfigKey(configKey);
        sysConfigHistoryEntity.setOldValue(oldValue);
        sysConfigHistoryEntity.setNewValue(configValue);
        sysConfigHistoryEntity.setOperatorId(operatorId);
        sysConfigHistoryEntity.setCreatedTime(new Date());
        configHistoryMapper.insert(sysConfigHistoryEntity);
        //更新配置
        SysConfigEntity sysConfigEntity1 = UpdateEntity.of(SysConfigEntity.class, id);
        sysConfigEntity1.setConfigValue(configValue);
        configMapper.update(sysConfigEntity1);
        //删除redis当中的缓存
        redisTemplate.delete("config:"+configKey);
        //刷新缓存
        refreshConfig();
    }

    /**
     * 根据条件查询配置历史，仅提供根据配置名称和配置人进行查询
     * @param configKey 配置名称
     * @param operatorId 配置人id
     * @return
     */
    @Override
    public List<SysConfigHistoryEntity> getHistoryList(String configKey, String operatorId,Integer page,Integer pageSize) {
        QueryWrapper queryWrapper = new QueryWrapper();
        queryWrapper.like("config_key",configKey);
        if(operatorId!=""){
            queryWrapper.eq("operator_id",operatorId);
        }
        List<SysConfigHistoryEntity> sysConfigHistoryEntities = configHistoryMapper.paginate(page, pageSize, queryWrapper).getRecords();
        return sysConfigHistoryEntities;
    }

    /**
     * 根据id查询配置详情
     * @param id 配置id
     * @return
     */
    @Override
    public SysConfigEntity getConfigDetail(Integer id) {
        return configMapper.selectOneById(id);
    }

    /**
     * 根据配置键查询配置详情
     * @param configKey 配置键
     * @return
     */
    @Override
    public List<SysConfigEntity> getConfigByKey(String configKey) {
        QueryWrapper queryWrapper = new QueryWrapper().like("config_key", configKey);
        return configMapper.selectListByQuery(queryWrapper);
    }
}
